package com.utils {

/**
 * 字符串一些常用方法。
 * @author boge
 *
 */
public class StringUtil {

	/** 验证是否是有效的html标签 */
	public static var HTML_TAG_REG:RegExp = /<[^>]*>/g;
	/** 验证是否是有效的网址 */
	public static const HTML_URL_REG:RegExp = /http(s)?:\/\/([\w-]+\.)+[\w-]+(\/[\w- .\/?%&=]*)?/g;

	/* 删除指定标签 */
//		private static var removeTag:RegExp = /<\/?TEXTFORMAT[^>]*>/gi;

	/** 支持字符串格式 ("{0}"). 格式化 */
	public static function format(format:String, ...args):String {
		for (var i:int = 0; i < args.length; ++i)
			format = format.replace(new RegExp("\\{" + i + "\\}", "g"), args[i]);
		return format;
	}

	/**
	 * 忽略大小字母比较字符是否相等
	 * @param    char1    字符串一
	 * @param    char2    字符串二
	 * @return            是否相等
	 */
	public static function equalsIgnoreCase(char1:String, char2:String):Boolean {
		return char1.toLowerCase() == char2.toLowerCase();
	}

	/**
	 * 是否是数值字符串
	 * @param    char    指定字符串
	 * @return            是否是数字
	 */
	public static function isNumber(char:String):Boolean {
		if (!char) {
			return false;
		}
		return !isNaN(Number(char));
	}

	/**
	 * 去除所有html 标签形式
	 * @param value
	 * @return
	 *
	 */
	public static function removeHtml(value:String):String {
		var str:String = value.replace(HTML_TAG_REG, "");
		if (str) {
			return trim(str);
		}
		return value;
	}

	/**
	 * 是否为合法 Email
	 * @param    char    指定字符串
	 * @return            是否合法
	 */
	public static function isEmail(char:String):Boolean {
		var reg:RegExp = new RegExp("^\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*$");
		return checkChar(char, reg);
	}

	/**
	 * 是否是 Double 型数据
	 * @param    char    指定字符串
	 * @return            是否是 Double 型
	 */
	public static function isDouble(char:String):Boolean {
		var pattern:RegExp = new RegExp("^[+\-]?\d+(\.\d+)?$");
		return checkChar(char, pattern);
	}

	/**
	 * 是否是整数
	 * @param    char    指定字符串
	 * @return            是否是整数
	 */
	public static function isInteger(char:String):Boolean {
		var pattern:RegExp = new RegExp("^[-\+]?\d+$");
		return checkChar(char, pattern);
	}

	/**
	 * 是否是英文字符（包括大小写）
	 * @param    char    指定字符串
	 * @return            是否是英文字符
	 */
	public static function isEnglish(char:String):Boolean {
		var pattern:RegExp = new RegExp("^[A-Za-z]+$");
		return checkChar(char, pattern);
	}

	/**
	 * 是否是中文
	 * @param    char    指定字符串
	 * @return            是否是中文
	 */
	public static function isChinese(char:String):Boolean {
		var pattern:RegExp = new RegExp("^[\u0391-\uFFE5]+$");
		return checkChar(char, pattern);
	}

	/**
	 * 万军从中取数字
	 * @param char
	 * @return
	 *
	 */
	public static function getNumbers(char:String):Number {
		var pattern:RegExp = new RegExp("\\d+");
		if (pattern.test(char)) {
			return Number(pattern.exec(char));
		}
		return 0;
	}

	/**
	 * 万军从中取非数字
	 * @param char
	 * @return
	 *
	 */
	public static function getNotNumbers(char:String):String {
		var pattern:RegExp = new RegExp("\\D+");
		if (pattern.test(char)) {
			return pattern.exec(char);
		}
		return "";
	}

	/**
	 * 是否是双字节
	 * @param    char    指定字符串
	 * @return            是否是双字节
	 */
	public static function isDoubleChar(char:String):Boolean {
		var pattern:RegExp = new RegExp("^[^\x00-\xff]+$");
		return checkChar(char, pattern);
	}

	/**
	 * 是否是 url 地址
	 * @param    char    指定字符串
	 * @return            是否是 url 地址
	 */
	public static function isURL(char:String):Boolean {
		if (!char) {
			return false;
		}
		char = char.toLowerCase();
//		var pattern:RegExp = /^http:\/\/[A-Za-z0-9]+\.[A-Za-z0-9]+[\/=\?%\-&_~`@[\]\':+!]*([^<>\"\"])*$/;
		return checkChar(char, HTML_URL_REG);
	}

	/**
	 * 是否为空白
	 * @param    char    指定字符串
	 * @return            是否为空白
	 * TODO：需要用正则匹配出多个空格的情况
	 */
	public static function isNullOrEmpty(char:String):Boolean {
		switch (char) {
			case null:
			case "":
			case "\t":
			case "\r":
			case "\n":
			case "\f":
				return true;
			default:
				return false;
		}
	}

	/**
	 * 是否包含中文
	 * @param    char    指定字符串
	 * @return            是否包含中文
	 */
	public static function hasChineseChar(char:String):Boolean {
		var pattern:RegExp = /[^\x00-\xff]/;
		return checkChar(char, pattern);
	}

	/**
	 * 检测指定字符串是否匹配指定模式
	 * @param    char    指定字符串
	 * @param    pattern    指定模式
	 * @return            是否匹配
	 */
	public static function checkChar(char:String, pattern:RegExp):Boolean {
		if (!char) {
			return false;
		}
		char = trim(char);
		return pattern.test(char);
	}

	/**
	 * 比较两个字符串是否相等
	 * @param s1 第一个比较字符串。
	 * @param s2 第二个比较字符串。
	 * @param caseSensitive 是否区分大小写  默认不区分
	 * @return 相等true
	 *
	 */
	public static function stringsAreEqual(s1:String, s2:String,
	                                       caseSensitive:Boolean = false):Boolean {
		if (caseSensitive) {
			return (s1 == s2);
		} else {
			return (s1.toUpperCase() == s2.toUpperCase());
		}
	}

	/**
	 * 去除首位的空白部分
	 * @param input 要被处理的字符串
	 * @return 已经被处理的字符串
	 *
	 */
	public static function trim(input:String):String {
		return StringUtil.ltrim(StringUtil.rtrim(input));
	}

	/**
	 * 从前面指定的字符串中删除空格。
	 * @param input 输入字符串开始的空白将被删除。
	 * @return 从一开始的字符串的空格去掉
	 *
	 */
	public static function ltrim(input:String):String {
		var size:Number = input.length;
		for (var i:Number = 0; i < size; i++) {
			if (input.charCodeAt(i) > 32) {
				return input.substring(i);
			}
		}
		return "";
	}

	/**
	 *
	 * 从指定的字符串的结尾删除空格。
	 *
	 * @param input 输入字符串结尾的空白将被删除。
	 * @return 从后面删除空白的字符串
	 *
	 */
	public static function rtrim(input:String):String {
		var size:Number = input.length;
		for (var i:Number = size; i > 0; i--) {
			if (input.charCodeAt(i - 1) > 32) {
				return input.substring(0, i);
			}
		}
		return "";
	}

	/**
	 *
	 *    确定是否按指定字符串开始。
	 *
	 *    @param 要被处理的字符串
	 *
	 *    @param 字符串的前缀
	 *
	 */
	public static function beginsWith(input:String, prefix:String):Boolean {
		if (!input) {
			return false;
		}
		return (prefix == input.substring(0, prefix.length));
	}

	/**
	 *    确定是否按指定字符串结束。
	 *
	 *    @param 要被处理的字符串
	 *
	 *    @param 字符串的后缀
	 *
	 */
	public static function endsWith(input:String, suffix:String):Boolean {
		if (!input) {
			return false;
		}
		return (suffix == input.substring(input.length - suffix.length));
	}

	/**
	 *
	 *    删除在输入字符串中删除字符串的所有实例。
	 *
	 *    @param input 要被处理的字符串
	 *
	 *    @param remove 要删除的字符串
	 *
	 *    @returns 已经被处理后的字符串
	 *
	 */
	public static function remove(input:String, remove:String):String {
		return replace(input, remove, "");
	}

	/**
	 *
	 *    字符串内容替换
	 *
	 *    @param input 要被处理的字符串
	 *
	 *    @param replace 要被替换掉的字符串
	 *
	 *    @param replaceWith 用来替换的新字符串
	 *
	 *    @returns 一个替换完毕的字符串
	 *
	 */
	public static function replace(input:String, replace:String, replaceWith:String):String {
		return input.split(replace).join(replaceWith);
	}

	/**
	 * 获取指定符号之后的字符串
	 * @param input 要处理的字符串
	 * @param suffix 要做为依据的最后一个符号
	 * @param retain 是否要保留作为依据的符号 (默认不保留)
	 * @param direction 是从前开始还是从后开始 (默认从后)
	 * <br>
	 * 例子 ： var str = "ssdw\aa"，使用  endsCode(str, "\") <br> 最后得到 aa
	 */
	public static function endsCode(input:String, suffix:String, retain:Boolean = false, direction:Boolean = false):String {
		var index:int;
		if (direction) {
			index = input.indexOf(suffix);
		} else {
			index = input.lastIndexOf(suffix);
		}
		if (index != -1) {
			if (retain) {
				input = input.substring(index, input.length);
			} else {
				input = input.substring(index + (suffix.length), input.length);
			}
		}
		return input;
	}

	/**
	 * 获取指定符号之前的字符串
	 * @param input 要处理的字符串
	 * @param suffix 要做为依据的最后一个符号
	 * @param retain 是否要保留作为依据的符号 (默认不保留)
	 * @param direction 是从前开始还是从后开始 (默认从后)
	 *
	 * @return
	 *
	 */
	public static function beginsCode(input:String, suffix:String, retain:Boolean = false, direction:Boolean = false):String {
		var index:int
		if (direction) {
			index = input.indexOf(suffix);
		} else {
			index = input.lastIndexOf(suffix);
		}
		if (index != -1) {
			if (retain) {
				input = input.substring(0, index + 1);
			} else {
				input = input.substring(0, index);
			}
		}
		return input;
	}

	/**
	 * 获取资源文件的名字
	 * @param url 路径名
	 * @param retain 是否去掉尾部标签
	 * @return
	 *
	 */
	public static function urlName(url:String, retain:Boolean = true):String {
		if (url.indexOf("\\") != -1) {
			url = url.replace(/\\/g, "/");
		}
		var index:int = url.lastIndexOf("/");
		if (retain) {
			url = url.substring(index + 1, url.lastIndexOf("."));
		} else {
			url = url.substring(index + 1, url.length);
		}
		return url;
	}

	/**
	 * 转换数据类型
	 * @param value 数据
	 * @param type 类型
	 * @return
	 *
	 */
	public static function changeType(value:String, type:String):* {
		var tempValue:* = value;
		switch (type) {
			case "int":
				tempValue = int(value);
				break;
			case "uint":
				tempValue = uint(value);
				break;
			case "number":
				tempValue = Number(value);
				break;
			case "boolean":
				if (isNumber(value)) {
					tempValue = int(value) > 0 ? true : false;
				} else {
					tempValue = Boolean(value);
				}
				break;
			case "array":
				tempValue = value.split(",");
				break;
			case "array,int":
				tempValue = value.split(",");
				for (var j:int = 0, len:int = tempValue.length; j < len; j++) {
					tempValue[j] = changeType(tempValue[j], "int");
				}
				break;
			case "array,number":
				tempValue = value.split(",");
				for (j = 0, len = tempValue.length; j < len; j++) {
					tempValue[j] = changeType(tempValue[j], "number");
				}
				break;
			case "array,uint":
				tempValue = value.split(",");
				for (j = 0, len = tempValue.length; j < len; j++) {
					tempValue[j] = changeType(tempValue[j], "uint");
				}
				break;
		}
		return tempValue;
	}


}

}